home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / libg_261.zip / libg_261 / libg++ / src / Fix24.cc < prev    next >
C/C++ Source or Header  |  1994-08-12  |  8KB  |  330 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /* 
  3. Copyright (C) 1988 Free Software Foundation
  4.     written by Kurt Baudendistel (gt-eedsp!baud@gatech.edu)
  5.     adapted for libg++ by Doug Lea (dl@rocky.oswego.edu)
  6.  
  7. This file is part of the GNU C++ Library.  This library is free
  8. software; you can redistribute it and/or modify it under the terms of
  9. the GNU Library General Public License as published by the Free
  10. Software Foundation; either version 2 of the License, or (at your
  11. option) any later version.  This library is distributed in the hope
  12. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  13. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14. PURPOSE.  See the GNU Library General Public License for more details.
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19.  
  20. //
  21. // Fix24.cc : fixed precision class support functions
  22. //
  23.  
  24. #ifdef __GNUG__
  25. #pragma implementation
  26. #endif
  27. #include <Fix24.h>
  28.  
  29. // basic operators too large to be inline
  30.  
  31. _G_int32_t Fix24::assign(double d) 
  32. { 
  33.   if (d == 1.0)
  34.     return Fix24_m_max;
  35.   else if (d > Fix24_max)
  36.   {
  37.     _G_int32_t i = Fix24_m_max;
  38.     range_error(i);
  39.     return i;
  40.   }
  41.   else if (d < Fix24_min)
  42.   {
  43.     _G_int32_t i = Fix24_m_min;
  44.     range_error(i);
  45.     return i;
  46.   }
  47.   else {
  48.     // Round to 24 bits
  49.     d = (_G_int32_t) (d * (1 << 24) + ((d >= 0)? 0.5 : -0.5));
  50.     /* Convert to integer format */
  51.     return ((_G_int32_t) d) << (Fix24_shift - 24);
  52.   }
  53. }
  54.  
  55. twolongs Fix48::assign(double d) 
  56. { 
  57.   if (d == 1.0)
  58.     return Fix48_m_max;
  59.   else if (d > Fix48_max)
  60.   {
  61.     twolongs i = Fix48_m_max;
  62.     range_error(i);
  63.     return i;
  64.   }
  65.   else if (d < Fix48_min)
  66.   {
  67.     twolongs i = Fix48_m_min;
  68.     range_error(i);
  69.     return i;
  70.   }
  71.   else {
  72.     twolongs i;
  73.     int sign = (d < 0);
  74.  
  75. /* First, convert the absolute value of d to a 48-bit integer format */
  76.     if (d < 0) d = -d;
  77.     i.u = ((_G_int32_t)(d *= Fix24_mult)) & 0xffffff00;
  78.     i.l = ((_G_uint32_t)((d - i.u)* (Fix24_mult / (1 << 7)))) & 0xffffff00;
  79.  
  80. /* Calculate the two's complement if d was negative */
  81.     if (sign) {
  82.     _G_uint32_t oldlower = i.l;
  83.     i.l = (~i.l + 1) & 0xffffff00;
  84.     i.u = (~i.u + (((oldlower ^ i.l) & Fix24_msb)? 0 : 1)) & ~0xffL;
  85.     }
  86.     return i;
  87.   }
  88. }
  89.  
  90.  
  91. Fix48 operator * (const Fix24& a, const Fix24& b)
  92. {
  93. // break a and b into lo and hi parts, and do a multiple-precision
  94. // multiply, with rounding
  95.  
  96.   int apos = (a.m >= 0);
  97.   _G_uint32_t ua = (apos)? a.m : - a.m;
  98.   ua <<= 1; // ua is biased so result will be 47 bit mantissa, not 46:
  99.   _G_uint32_t hi_a = (ua >> 16) & ((1 << 16) - 1);
  100.   _G_uint32_t lo_a = ua & ((1 << 16) - 1);
  101.  
  102.   int bpos = (b.m >= 0);
  103.   _G_uint32_t ub = (bpos)? b.m : -b.m;
  104.   _G_uint32_t hi_b = (ub >> 16) & ((1 << 16) - 1);
  105.   _G_uint32_t lo_b = ub & ((1 << 16) - 1);
  106.  
  107.   _G_uint32_t 
  108.     hi_r = hi_a * hi_b,
  109.     mi_r = hi_a * lo_b + lo_a * hi_b,
  110.     lo_r = lo_a * lo_b,
  111.     rl = ((hi_r << 16) & 0x00ffffffL) + (mi_r & 0x00ffffffL) + (lo_r >> 16);
  112.   twolongs r;
  113.   r.u = (hi_r & 0xffffff00L) + ((mi_r >> 16) & 0x0000ff00L)
  114.     + ((rl >> 16) & 0x0000ff00L);
  115.   r.l = rl << 8;
  116.  
  117.   if ( apos != bpos ) {
  118.     _G_uint32_t l = r.l;
  119.     r.l = -r.l;
  120.     r.u = (~r.u + ((l ^ r.l) & Fix24_msb ? 0 : Fix24_lsb)) & 0xffffff00;
  121.   }
  122.   return r;
  123. }
  124.  
  125. Fix24 operator / (const Fix24& a, const Fix24& b)
  126. {
  127.   _G_int32_t q;
  128.   int apos = (a.m >= 0);
  129.   _G_uint32_t la = (apos)? a.m : -a.m;
  130.   int bpos = (b.m >= 0);
  131.   _G_uint32_t lb = (bpos)? b.m: -b.m;
  132.   if (la >= lb)
  133.   {
  134.     q = (apos == bpos)? Fix24_m_max: Fix24_m_min;
  135.     a.range_error(q);
  136.   }
  137.   else                        // standard shift-based division alg
  138.   {
  139.     q = 0;
  140.     _G_int32_t r = la;
  141.  
  142.     for (int i = 32; i > 0; i--)
  143.     {
  144.     if ((unsigned)(r) > lb) {
  145.         q = (q << 1) | 1;
  146.         r -= lb;
  147.     }
  148.     else
  149.         q = (q << 1);
  150.     r <<= 1;
  151.     }
  152.  
  153.     q += 0x80;            // Round result to 24 bits
  154.     if (apos != bpos) q = -q;    // Fix sign
  155.   }
  156.   return (q & ~0xff);
  157. }
  158.  
  159.  
  160. Fix48 operator + (const Fix48&  f, const Fix48&  g)
  161. {
  162.   _G_int32_t lo_r = (f.m.l >> 8) + (g.m.l >> 8);
  163.   twolongs r;
  164.   r.u = f.m.u + g.m.u + (lo_r & 0x01000000L ? 0x00000100L : 0);
  165.   r.l =  lo_r << 8;
  166.  
  167.   if ( (f.m.u ^ r.u) & (g.m.u ^ r.u) & Fix24_msb )
  168.     f.overflow(r);
  169.   return r;
  170. }
  171.  
  172. Fix48 operator - (const Fix48&  f, const Fix48&  g)
  173. {
  174.   unsigned lo_r = (f.m.l >> 8) - (g.m.l >> 8);
  175.   twolongs r;
  176.   r.u = f.m.u - g.m.u - (lo_r & 0x01000000L ? 0x00000100L: 0);
  177.   r.l = lo_r << 8;
  178.  
  179.   if ( ((f.m.u ^ r.u) & (-g.m.u ^ r.u) & Fix24_msb) && g.m.u )
  180.     f.overflow(r);
  181.   return r;
  182. }
  183.  
  184. Fix48 operator * (const Fix48& a, int b)
  185. {
  186.   twolongs r;
  187.   int bpos = (b >= 0);
  188.   unsigned ub = (bpos)? b : -b;
  189.   if ( ub >= 65536L ) {
  190.     r = (bpos)? Fix48_m_max : Fix48_m_min;
  191.     a.range_error(r);
  192.   }
  193.   else {
  194.     _G_uint32_t 
  195.       lo_r = (a.m.l & 0xffff) * ub,
  196.       mi_r = ((a.m.l >> 16) & 0xffff) * ub,
  197.       hi_r = a.m.u * ub;
  198.     r.l = lo_r + (mi_r << 16);
  199.     r.u = hi_r + ((mi_r >> 8) & 0x00ffff00L);
  200.     if ( !bpos ) {
  201.       _G_uint32_t l = r.l;
  202.       r.l = -r.l & 0xffffffff;
  203.       r.u = ~r.u + ((l ^ r.l) & Fix24_msb ? 0 : Fix24_lsb);
  204.     }
  205.   }
  206.   return r;
  207. }
  208.  
  209. Fix48 operator << (const Fix48& a, int b)
  210. {
  211.   twolongs r; r.u = 0; r.l = 0;
  212.   if ( b >= 0 )
  213.     if ( b < 24 ) {
  214.       r.u = (a.m.u << b) + ((a.m.l >> (24 - b)) & 0xffffff00L);
  215.       r.l = a.m.l << b;
  216.     }
  217.     else if ( b < 48 ) {
  218.       r.u = a.m.l << (b - 24);
  219.     }
  220.   return r;
  221. }
  222.  
  223. Fix48 operator >> (const Fix48& a, int b)
  224. {
  225.   twolongs r; r.u = 0; r.l = 0;
  226.   if ( b >= 0 )
  227.     if ( b < 24 ) {
  228.       r.l = ((a.m.u << (24 - b)) & 0xffffffffL) + ((a.m.l >> b) & 0xffffff00L);
  229.       r.u = (a.m.u >> b) & ~0xffL;
  230.     }
  231.     else if ( b < 48 ) {
  232.       r.l = (a.m.u >> (b - 24)) & 0xffffff00L;
  233.       r.u = (a.m.u >> 24) & ~0xffL;
  234.     }
  235.     else {
  236.       r.l = (a.m.u >> 24) & ~0xffL;
  237.       r.u = r.l;
  238.     }
  239.   return r;
  240. }
  241.  
  242. // error handling
  243.  
  244. void Fix24::overflow(_G_int32_t& i) const
  245. {
  246.   (*Fix24_overflow_handler)(i);
  247. }
  248.  
  249. void Fix48::overflow(twolongs& i) const
  250. {
  251.   (*Fix48_overflow_handler)(i);
  252. }
  253.  
  254. void Fix24::range_error(_G_int32_t& i) const
  255. {
  256.   (*Fix24_range_error_handler)(i);
  257. }
  258.  
  259. void Fix48::range_error(twolongs& i) const
  260. {
  261.   (*Fix48_range_error_handler)(i);
  262. }
  263.  
  264. // data definitions
  265.  
  266. Fix24_peh Fix24_overflow_handler = Fix24_overflow_saturate;
  267. Fix48_peh Fix48_overflow_handler = Fix48_overflow_saturate;
  268.  
  269. Fix24_peh Fix24_range_error_handler = Fix24_warning;
  270. Fix48_peh Fix48_range_error_handler = Fix48_warning;
  271.  
  272. //function definitions
  273.  
  274. Fix24_peh set_Fix24_overflow_handler(Fix24_peh new_handler) {
  275.   Fix24_peh old_handler = Fix24_overflow_handler;
  276.   Fix24_overflow_handler = new_handler;
  277.   return old_handler;
  278. }
  279.  
  280. Fix48_peh set_Fix48_overflow_handler(Fix48_peh new_handler) {
  281.   Fix48_peh old_handler = Fix48_overflow_handler;
  282.   Fix48_overflow_handler = new_handler;
  283.   return old_handler;
  284. }
  285.  
  286. void set_overflow_handler(Fix24_peh handler24, Fix48_peh handler48) {
  287.   set_Fix24_overflow_handler(handler24);
  288.   set_Fix48_overflow_handler(handler48);
  289. }
  290.  
  291. Fix24_peh set_Fix24_range_error_handler(Fix24_peh new_handler) {
  292.   Fix24_peh old_handler = Fix24_range_error_handler;
  293.   Fix24_range_error_handler = new_handler;
  294.   return old_handler;
  295. }
  296.  
  297. Fix48_peh set_Fix48_range_error_handler(Fix48_peh new_handler) {
  298.   Fix48_peh old_handler = Fix48_range_error_handler;
  299.   Fix48_range_error_handler = new_handler;
  300.   return old_handler;
  301. }
  302.  
  303. void set_range_error_handler(Fix24_peh handler24, Fix48_peh handler48) {
  304.   set_Fix24_range_error_handler(handler24);
  305.   set_Fix48_range_error_handler(handler48);
  306. }
  307.  
  308. void Fix24_overflow_saturate(_G_int32_t& i)
  309.   { i = (i > 0 ? Fix24_m_min : Fix24_m_max); }
  310. void Fix24_ignore(_G_int32_t&) {}
  311. void Fix24_warning(_G_int32_t&)
  312.   { cerr << "warning: Fix24 result out of range\n"; }
  313. void Fix24_overflow_warning_saturate(_G_int32_t& i)
  314.   { cerr << "warning: Fix24 result out of range\n"; 
  315.    Fix24_overflow_saturate(i); }
  316. void Fix24_abort(_G_int32_t&)
  317.   { cerr << "error: Fix24 result out of range\n"; abort(); }
  318.  
  319. void Fix48_ignore(twolongs&) {}
  320. void Fix48_overflow_saturate(twolongs& i)
  321.   { i = (i.u > 0 ? Fix48_m_min : Fix48_m_max); }
  322. void Fix48_warning(twolongs&)
  323.   { cerr << "warning: Fix48 result out of range\n"; }
  324. void Fix48_overflow_warning_saturate(twolongs& i)
  325.   { cerr << "warning: Fix48 result out of range\n"; 
  326.    Fix48_overflow_saturate(i); }
  327. void Fix48_abort(twolongs&)
  328.   { cerr << "error: Fix48 result out of range\n"; abort(); }
  329.  
  330.